Lazy initialization is a process by which an object is not initialized until it is first called in your code. The .NET 4.0 introduces a new wrapper class, System.Lazy, for executing the lazy initialization in your application. Lazy initialization helps you to reduce the wastage of resources and memory requirements to improve performance. It also supports thread-safety.

Memory management in the CLR is divided into three generations that are build up by grouping memory segments. Generations enhance the garbage collection performance. The following are the three types of generations found in a garbage collector:
• Generation 0 - When an object is initialized, it is said to be in generation 0.
• Generation 1 - The objects that are under garbage collection process are considered to be in generation 1.
• Generation 2 - Whenever new objects are created and added to the memory, they are added to generation 0 and the old objects in generation 1 are considered to be in generation 2.

In .NET 4.0, the CLR supports covariance and contravariance of types in generic interfaces and delegates. Covariance enables you to cast a generic type to its base types, that is, you can assign a instance of typeIEnumerable to a variable of type IEnumerable where, T1 derives from T2. For example,
IEnumerable str1= new List ();
IEnumerable

The following are the different ways to assign a value to a complex number:

By passing two Double values to its constructor. The first value represents the real, and the second value represents imaginary part of a complex number.
For example,
Complex c1 = new Complex(5, 8); /* It represents (5, 8) */

By assigning a Byte, SByte, Intl6, UIntl6, Int32, UInt32, Int64, UInt64, Single, or Double value to aComplex object. The assigned value represents the real part of the complex number, and its imaginary part becomes 0. For example,
Complex c2 = 15.3; /* It represents (15.3, 0) */

By casting a Decimal or BigInteger value to a Complex object.
For example,
Complex c3 = (Complex) 14.7; /* It represents (14.7, 0) */

Assigning the value returned by an operator to a Complex variable.
For example,
Complex c4 = c1 + c2; /* It represents (20.3, 8) */

CLS is a set of basic rules, which must be followed by each .NET language to be a .NET- compliant language. It enables interoperability between two .NET-compliant languages. CLS is a subset of CTS; therefore, the languages supported by CLS can use each other's class libraries similar to their own. Application programming interfaces (APIs), which are designed by following the rules defined in CLS can be used by all .NET-compliant languages.